package com.sbtr.common.calculate;

import com.sbtr.common.enums.CalculateEnum;
import com.sbtr.common.interfaces.Calculate;
import org.junit.Test;

import java.util.Date;
/**
 * @Author maojianping
 * @Date 2021/11/22
 * @Version 1.0
 * 用途：数据预处理工具类
 * 用于比较对象之间的大小关系和相等关系。其中包括判断两个对象是否相等、判断一个对象是否大于另一个对象、判断一个对象是否小于另一个对象等方法。
 */
public class DataFilterUtils {

//    private DataFilterUtils() { }

    /**
     * 判断两个对象是否相等
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否相等
     */
    @Calculate(CalculateEnum.isEqual)
    public static boolean isEqual(Object obj1, Object obj2) {
        if (obj1 == null && obj2 == null)
            return true;

        if (obj1 == null || obj2 == null)
            return false;

        return obj1.equals(obj2);
    }

    /**
     * 判断两个对象是否不相等
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否不相等
     */
    @Calculate(CalculateEnum.isNotEqual)
    public static boolean isNotEqual(Object obj1, Object obj2) {
        return !isEqual(obj1, obj2);
    }

    /**
     * 判断一个对象是否大于另一个对象
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否大于
     */
    @Calculate(CalculateEnum.isGreaterThan)
    public static boolean isGreaterThan(Comparable obj1, Comparable obj2) {
        if (obj1 == null || obj2 == null)
            return false;

        return obj1.compareTo(obj2) > 0;
    }

    /**
     * 判断一个对象是否小于另一个对象
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否小于
     */
    @Calculate(CalculateEnum.isLessThan)
    public static boolean isLessThan(Comparable obj1, Comparable obj2) {
        if (obj1 == null || obj2 == null)
            return false;

        return obj1.compareTo(obj2) < 0;
    }

    /**
     * 判断一个对象是否大于等于另一个对象
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否大于等于
     */
    @Calculate(CalculateEnum.isGreaterThanOrEqual)
    public static boolean isGreaterThanOrEqual(Comparable obj1, Comparable obj2) {
        if (obj1 == null || obj2 == null)
            return false;

        return obj1.compareTo(obj2) >= 0;
    }
    /**
     * 判断一个对象是否小于等于另一个对象
     * @param obj1 对象1
     * @param obj2 对象2
     * @return 是否小于等于
     */
    @Calculate(CalculateEnum.isLessThanOrEqual)
    public static boolean isLessThanOrEqual(Comparable obj1, Comparable obj2) {
        if (obj1 == null || obj2 == null)
            return false;

        return obj1.compareTo(obj2) <= 0;
    }

    /**
     * 大于、等于、小于等判断方法测试
     */
    @Test
    public void testIsEqualAndIsGreaterThanAll() {
        // 字符串类型测试案例
        String str1 = "hello";
        String str2 = "world";
        String str3 = "hello";
        System.out.println("str1和str2是否相等：" + DataFilterUtils.isEqual(str1, str2)); // false
        System.out.println("str1和str3是否相等：" + DataFilterUtils.isEqual(str1, str3)); // true
        System.out.println("str1是否大于str2：" + DataFilterUtils.isGreaterThan(str1, str2)); // false
        System.out.println("str1是否小于str2：" + DataFilterUtils.isLessThan(str1, str2)); // true

        // 数值类型测试案例
        Integer int1 = 10;
        Integer int2 = 20;
        Integer int3 = 10;
        System.out.println("int1和int2是否相等：" + DataFilterUtils.isEqual(int1, int2)); // false
        System.out.println("int1和int3是否相等：" + DataFilterUtils.isEqual(int1, int3)); // true
        System.out.println("int1是否大于int2：" + DataFilterUtils.isGreaterThan(int1, int2)); // false
        System.out.println("int1是否小于int2：" + DataFilterUtils.isLessThan(int1, int2)); // true

        // 日期类型测试案例
        Date date1 = new Date(2021, 1, 1);
        Date date2 = new Date(2022, 1, 1);
        Date date3 = new Date(2021, 1, 1);
        System.out.println("date1和date2是否相等：" + DataFilterUtils.isEqual(date1, date2)); // false
        System.out.println("date1和date3是否相等：" + DataFilterUtils.isEqual(date1, date3)); // true
        System.out.println("date1是否大于date2：" + DataFilterUtils.isGreaterThan(date1, date2)); // false
        System.out.println("date1是否小于date2：" + DataFilterUtils.isLessThan(date1, date2)); // true
    }

    /**
     * 保留小数点后几位
     * @param num 需要保留的小数
     * @param scale 保留的位数
     * @return 保留后的结果
     */
    @Calculate(CalculateEnum.round)
    public static double round(double num, int scale) {
        return Math.round(num * Math.pow(10, scale)) / Math.pow(10, scale);
    }

    /**
     * 测试 截取保留几位小数
     */
    @Test
    public void testRound() {
        double num = 3.14159265358979323846;
        double num1 = 0.19323841;
        int scale = 3;
        int scale1 = 1;
        double result = round(num, scale);
        double result1 = round(num1, scale1);
        System.out.println("result保留小数点后" + scale + "位的结果为：" + result);
        System.out.println("result1保留小数点后" + scale1 + "位的结果为：" + result1);
    }

    @Calculate(CalculateEnum.isContain)
    public static boolean isContain(String obj1, String obj2) {
        if (obj1 == null || obj2 == null)
            return false;

        return obj1.contains(obj2);
    }
    @Calculate(CalculateEnum.isNoContain)
    public static boolean isNoContain(String obj1, String obj2) {
        if (obj1 == null || obj2 == null)
            return false;
        return !obj1.contains(obj2);
    }

    @Calculate(CalculateEnum.inStart)
    public static boolean isStart(String obj1, String obj2) {
        if (obj1 == null || obj2 == null)
            return false;
        return obj2.indexOf(obj1)==0;
    }


    @Calculate(CalculateEnum.inEnd)
    public static boolean inEnd(String obj1, String obj2) {
        if (obj1 == null || obj2 == null)
            return false;
        return obj2.endsWith(obj1);
    }


}